---
id: tracker-stores
sidebar_label: Tracker Stores
title: Tracker Stores
description: All conversations are stored within a tracker store. Read how Rasa provides implementations for different store types out of the box.
abstract: Your assistant's conversations are stored within a tracker store.
  Rasa provides implementations for different store types out of the box,
  or you can create your own custom one.
---

<!-- this file is version specific, do not use `@site/...` syntax -->
import variables from './variables.json';

## InMemoryTrackerStore (default)

`InMemoryTrackerStore` is the default tracker store. It is used if no other
tracker store is configured. It stores the conversation history in memory.

:::note
As this store keeps all history in memory, the entire history is lost if you restart the Rasa server.

:::



### **Configuration**

No configuration is needed to use the `InMemoryTrackerStore`.


## SQLTrackerStore

You can use an `SQLTrackerStore` to store your assistant's conversation history in an SQL database.

### Configuration

To set up Rasa with SQL the following steps are required:

1. Add required configuration to your `endpoints.yml`:

 ```yaml-rasa title="endpoints.yml"
 tracker_store:
     type: SQL
     dialect: "postgresql"  # the dialect used to interact with the db
     url: ""  # (optional) host of the sql db, e.g. "localhost"
     db: "rasa"  # path to your db
     username:  # username used for authentication
     password:  # password used for authentication
     query: # optional dictionary to be added as a query string to the connection URL
       driver: my-driver
 ```

2. To start the Rasa server using your SQL backend,
 add the `--endpoints` flag, e.g.:

 ```bash
 rasa run -m models --endpoints endpoints.yml
 ```

3. If deploying your model in Docker Compose, add the service to your `docker-compose.yml`:

 ```yaml-rasa title="docker-compose.yml"
 postgres:
   image: postgres:latest
 ```

 To route requests to the new service, make sure that the `url` in your `endpoints.yml`
 references the service name:

 ```yaml-rasa {4} title="endpoints.yml"
   tracker_store:
       type: SQL
       dialect: "postgresql"  # the dialect used to interact with the db
       url: "postgres"
       db: "rasa"  # path to your db
       username:  # username used for authentication
       password:  # password used for authentication
       query: # optional dictionary to be added as a query string to the connection URL
         driver: my-driver
 ```

#### Configuration Parameters

* `domain` (default: `None`): Domain object associated with this tracker store

* `dialect` (default: `sqlite`): The dialect used to communicate with your SQL backend.  Consult the [SQLAlchemy docs](https://docs.sqlalchemy.org/en/latest/core/engines.html#database-urls) for available dialects.

* `url` (default: `None`): URL of your SQL server

* `port` (default: `None`): Port of your SQL server

* `db` (default: `rasa.db`): The path to the database to be used

* `username` (default: `None`): The username which is used for authentication

* `password` (default: `None`): The password which is used for authentication

* `event_broker` (default: `None`): Event broker to publish events to

* `login_db` (default: `None`): Alternative database name to which initially  connect, and create the database specified by `db` (PostgreSQL only)

* `query` (default: `None`): Dictionary of options to be passed to the dialect and/or the DBAPI upon connect



#### Compatible Databases

The following databases are officially compatible with the `SQLTrackerStore`:
  * PostgreSQL
  * Oracle > 11.0
  * SQLite

#### Configuring Oracle

To use the SQLTrackerStore with Oracle, there are a few additional steps.
First, create a database `tracker` in your Oracle database and create a user with access to it.
Create a sequence in the database with the following command, where username is the user you created
(read more about creating sequences in the [Oracle Documentation](https://docs.oracle.com/cd/B28359_01/server.111/b28310/views002.htm#ADMIN11794)):

```sql
CREATE SEQUENCE username.events_seq;
```

Next you have to extend the Rasa image to include the necessary drivers and clients.
First download the [Oracle Instant Client](https://www.oracle.com/database/technologies/instant-client/linux-x86-64-downloads.html),
rename it to `oracle.rpm` and store it in the directory from where you'll be building the docker image.
Copy the following into a file called `Dockerfile`:

<pre><code parentName="pre" className="language-bash">
{`FROM rasa/rasa:${variables.release}-full

# Switch to root user to install packages
USER root

RUN apt-get update -qq && apt-get install -y --no-install-recommends alien libaio1 && apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*

# Copy in oracle instaclient
# https://www.oracle.com/database/technologies/instant-client/linux-x86-64-downloads.html
COPY oracle.rpm oracle.rpm

# Install the Python wrapper library for the Oracle drivers
RUN pip install cx-Oracle

# Install Oracle client libraries
RUN alien -i oracle.rpm

USER 1001`}
</code></pre>

Then build the docker image:

<pre><code parentName="pre" className="language-bash">
{`docker build . -t rasa-oracle:${variables.release}-oracle-full`}
</code></pre>

Now you can configure the tracker store in the `endpoints.yml` as described above,
and start the container. The `dialect` parameter with this setup will be `oracle+cx_oracle`.
Read more about [Deploying a Rasa Assistant](./deploy/introduction.mdx).


## RedisTrackerStore

You can store your assistant's conversation history in [Redis](https://redis.io/) by using the
`RedisTrackerStore`.
Redis is a fast in-memory key-value store which can optionally also persist data.



### Configuration

To set up Rasa with Redis the following steps are required:

1. Start your Redis instance

2. Add required configuration to your `endpoints.yml`:

 ```yaml-rasa title="endpoints.yml"
 tracker_store:
     type: redis
     url: <url of the redis instance, e.g. localhost>
     port: <port of your redis instance, usually 6379>
     key_prefix: <alphanumeric value to prepend to tracker store keys>
     db: <number of your database within redis, e.g. 0>
     password: <password used for authentication>
     use_ssl: <whether or not the communication is encrypted, default `false`>
 ```

 ```bash
 rasa run -m models --endpoints endpoints.yml
 ```

4. If deploying your model in Docker Compose, add the service to your `docker-compose.yml`:

 ```yaml-rasa title="docker-compose.yml"
 redis:
   image: redis:latest
 ```

 To route requests to the new service, make sure that the `url` in your `endpoints.yml`
 references the service name:

 ```yaml-rasa {3} title="endpoints.yml"
  tracker_store:
      type: redis
      url: <url of the redis instance, e.g. localhost>
      port: <port of your redis instance, usually 6379>
      db: <number of your database within redis, e.g. 0>
      key_prefix: <alphanumeric value to prepend to tracker store keys>
      password: <password used for authentication>
      use_ssl: <whether or not the communication is encrypted, default `false`>
 ```

* `url` (default: `localhost`): The url of your redis instance

* `port` (default: `6379`): The port which redis is running on

* `db` (default: `0`): The number of your redis database

* `key_prefix` (default: `None`): The prefix to prepend to tracker store keys. Must
    be alphanumeric

* `username` (default: `None`): Username used for authentication

* `password` (default: `None`): Password used for authentication
(`None` equals no authentication)

* `record_exp` (default: `None`): Record expiry in seconds

* `use_ssl` (default: `False`): whether or not to use SSL for transit encryption

## MongoTrackerStore


You can store your assistant's conversation history in [MongoDB](https://www.mongodb.com/) using the `MongoTrackerStore`.
MongoDB is a free and open-source cross-platform document-oriented NoSQL database.

### Configuration

1. Start your MongoDB instance.

2. Add required configuration to your `endpoints.yml`:

 ```yaml-rasa title="endpoints.yml"
 tracker_store:
     type: mongod
     url: <url to your mongo instance, e.g. mongodb://localhost:27017>
     db: <name of the db within your mongo instance, e.g. rasa>
     username: <username used for authentication>
     password: <password used for authentication>
     auth_source: <database name associated with the user's credentials>
 ```

 You can also add more advanced configurations (like enabling ssl) by appending
 a parameter to the url field, e.g. `mongodb://localhost:27017/?ssl=true`.

3. To start the Rasa server using your configured MongoDB instance,
 add the `--endpoints` flag, for example:

 ```bash
 rasa run -m models --endpoints endpoints.yml
 ```

4. If deploying your model in Docker Compose, add the service to your `docker-compose.yml`:

 ```yaml-rasa title="docker-compose.yml"
 mongo:
   image: mongo
   environment:
     MONGO_INITDB_ROOT_USERNAME: rasa
     MONGO_INITDB_ROOT_PASSWORD: example
 mongo-express:  # this service is a MongoDB UI, and is optional
   image: mongo-express
   ports:
     - 8081:8081
   environment:
     ME_CONFIG_MONGODB_ADMINUSERNAME: rasa
     ME_CONFIG_MONGODB_ADMINPASSWORD: example
 ```

 To route requests to this database, make sure to set the `url` in your `endpoints.yml` as the service name,
 and specify the user and password:

 ```yaml-rasa {3,5,6} title="endpoints.yml"
  tracker_store:
      type: mongod
      url: mongodb://mongo:27017
      db: <name of the db within your mongo instance, e.g. rasa>
      username: <username used for authentication>
      password: <password used for authentication>
      auth_source: <database name associated with the user's credentials>
 ```



#### Configuration Parameters

* `url` (default: `mongodb://localhost:27017`): URL of your MongoDB

* `db` (default: `rasa`): The database name which should be used

* `username` (default: `0`): The username which is used for authentication

* `password` (default: `None`): The password which is used for authentication

* `auth_source` (default: `admin`): database name associated with the user's credentials.

* `collection` (default: `conversations`): The collection name which is
used to store the conversations


## DynamoTrackerStore

You can store your assistant's conversation history in
[DynamoDB](https://aws.amazon.com/dynamodb/) by using a `DynamoTrackerStore`.
DynamoDB is a hosted NoSQL database offered by Amazon Web Services (AWS).


### Configuration

1. Start your DynamoDB instance.

2. Add required configuration to your `endpoints.yml`:

 ```yaml-rasa title="endpoints.yml"
 tracker_store:
     type: dynamo
     table_name: <name of the table to create, e.g. rasa>
     region: <name of the region associated with the client>
 ```

3. To start the Rasa server using your configured `DynamoDB` instance,
 add the `--endpoints` flag, e.g.:

 ```bash
 rasa run -m models --endpoints endpoints.yml
 ```


#### Configuration Parameters

* `table_name` (default: `states`): name of the DynamoDB table

* `region` (default: `us-east-1`): name of the region associated with the client


## Custom Tracker Store

If you need a tracker store which is not available out of the box, you can implement your own.
This is done by extending the base class `TrackerStore` and one of the provided mixin classes that implement the
`serialise_tracker` method: `SerializedTrackerAsText` or `SerializedTrackerAsDict`.

To write a custom tracker store, extend the `TrackerStore` base class. Your constructor has to
provide a parameter `host`.
The constructor also needs to make a `super` call to the base class `TrackerStore` using `domain` and `event_broker` arguments:

```
super().__init__(domain, event_broker, **kwargs)
```

Your custom tracker store class must also implement the following three methods:
- `save`: saves the conversation to the tracker store. [(source code - see for signature)](https://github.com/RasaHQ/rasa/blob/main/rasa/core/tracker_store.py#L243).
- `retrieve`: retrieves tracker for the latest conversation session. [(source code - see for signature)](https://github.com/RasaHQ/rasa/blob/main/rasa/core/tracker_store.py#L261).
- `keys`: returns the set of values for the tracker store's primary key. [(source code - see for signature)](https://github.com/RasaHQ/rasa/blob/main/rasa/core/tracker_store.py#L319).

### Configuration

Put the module path to your custom tracker store and the parameters you require in your `endpoints.yml`:

 ```yaml-rasa title="endpoints.yml"
 tracker_store:
   type: path.to.your.module.Class
   url: localhost
   a_parameter: a value
   another_parameter: another value
 ```

If you are deploying in Docker Compose, you have two options to add this store to Rasa:
extending the Rasa image to include the module, or mounting the module as volume.

 Make sure to add the corresponding service as well. For example, mounting it as a volume would look like so:

 ```yaml {5,6,7} title="docker-compose.yml"
 rasa:
   <existing rasa service configuration>
   volumes:
     - <existing volume mappings, if there are any>
     - ./path/to/your/module.py:/app/path/to/your/module.py
 custom-tracker-store:
   image: custom-image:tag
 ```

 ```yaml-rasa {3} title="endpoints.yml"
 tracker_store:
   type: path.to.your.module.Class
   url: custom-tracker-store
   a_parameter: a value
   another_parameter: another value
 ```

## Fallback Tracker Store

In case the primary tracker store configured in `endpoints.yml` becomes unavailable, the rasa agent will issue an
error message and fall back on the `InMemoryTrackerStore` implementation. A new dialogue session will be started for
each turn, which will be saved separately in the `InMemoryTrackerStore` fallback.

As soon as the primary tracker store comes back up, it will replace the fallback tracker store and save the
conversation from this point going forward. However, note that any previous states saved in the `InMemoryTrackerStore`
fallback will be lost.

:::warning Using the same redis instance as lock-store and tracker store

You must not use the same Redis instance as both lock store and tracker store.
If the Redis instance becomes unavailable, the conversation will hang because there is no fall back mechanism
implemented for the lock store (as it is for the tracker store interfaces).
:::
